package com.ictest.detectionflow.mobile;

import java.io.InputStreamReader;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Base64;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import com.ictest.detectionflow.mobile.model.ComponentQueryCondition;

/**
 * 元器件视图。
 */
public class ComponentActivity extends Activity
{
	/**
	 * 数据库操作辅助对象。
	 */
	private DatabaseHelper m_Helper;

	/**
	 * 日志标记。
	 */
	private final static String LOG_TAG = "ComponentActivity";

	/**
	 * 设置活动编号。
	 */
	public final static int CODE_SETTING = 100;

	/**
	 * 检索活动编号。
	 */
	private final static int CODE_SEARCH = 200;

	/**
	 * 检索条件。
	 */
	private ComponentQueryCondition m_Condition;

	/**
	 * 元器件列表视图适配器。
	 */
	private ComponentListAdapter m_ListAdapter;

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		// 调用基类实现
		super.onCreate(savedInstanceState);

		// 设置内容视图
		setContentView(R.layout.activity_component);

		// 创建数据库辅助对象
		this.m_Helper = new DatabaseHelper(ComponentActivity.this);

		// 读取检索条件
		this.loadQueryCondition();

		// 获得元器件列表视图
		ListView lstComponent = (ListView) this.findViewById(R.id.lstComponent);

		// 创建元器件列表视图适配器
		this.m_ListAdapter = new ComponentListAdapter();

		// 设置列表视图适配器
		lstComponent.setAdapter(this.m_ListAdapter);

		// 挂接列表视图项目点击事件监听
		lstComponent.setOnItemClickListener(new OnItemClickListener()
		{
			// 处理点击事件
			public void onItemClick(AdapterView<?> adapter, View view, int position, long row)
			{
				// 创建额外参数
				Bundle extras = new Bundle();

				// 添加参数
				extras.putString("ID", (String) adapter.getItemAtPosition(position));

				// 启动活动
				Utility.startActivity(ComponentActivity.this, ComponentDetailActivity.class, extras);
			}
		});

		// 获得返回按钮
		ImageButton cmdBack = (ImageButton) this.findViewById(R.id.cmdBack);

		// 挂接点击事件监听
		cmdBack.setOnClickListener(new View.OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 结束页面
				ComponentActivity.this.finish();
			}
		});

		// 获得同步按钮
		ImageButton cmdSync = (ImageButton) this.findViewById(R.id.cmdSync);

		// 挂接点击事件监听
		cmdSync.setOnClickListener(new View.OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 执行数据同步
				ComponentActivity.this.doSync();
			}
		});

		// 获得关键字输入框
		EditText txtKeyword = (EditText) ComponentActivity.this.findViewById(R.id.txtKeyword);

		// 设置关键字
		txtKeyword.setText(this.m_Condition.getKeyword());

		// 全选文字
		txtKeyword.selectAll();

		// 获得检索按钮
		ImageButton cmdSearch = (ImageButton) this.findViewById(R.id.cmdSearch);

		// 挂接点击事件监听
		cmdSearch.setOnClickListener(new View.OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 获得关键字输入框
				EditText txtKeyword = (EditText) ComponentActivity.this.findViewById(R.id.txtKeyword);

				// 获得关键字
				String keyword = txtKeyword.getText().toString();

				// 判断是否输入了内容
				if (null == keyword || keyword.length() == 0)
				{
					// 提示信息
					Toast.makeText(ComponentActivity.this, "请填写检索关键字。", Toast.LENGTH_SHORT).show();

					// 全部选中
					txtKeyword.selectAll();

					// 设置焦点
					txtKeyword.requestFocus();

					// 返回
					return;
				}

				// 设置关键字
				ComponentActivity.this.m_Condition.setKeyword(keyword);

				// 设置使用关键字检索
				ComponentActivity.this.m_Condition.setUseKeyword(true);

				// 判断是否有检索条件
				if (Utility.IsNullOrEmpty(ComponentActivity.this.m_Condition.getKeyword()))
				{
					// 如果没有检索条件，则直接返回
					return;
				}

				// 执行查询
				ComponentActivity.this.m_ListAdapter.doQuery(ComponentActivity.this.m_Condition);

				// 隐藏软键盘
				((InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(ComponentActivity.this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
			}
		});

		// 判断条件是否有效

	}

	@Override
	protected void onStop()
	{
		// 调用基类实现
		super.onStop();

		// 保存检索条件
		this.saveQueryCondition();
	}

	@Override
	protected void onDestroy()
	{
		// 调用基类实现
		super.onDestroy();

		// 关闭适配器
		this.m_ListAdapter.close();

		// 清除适配器
		this.m_ListAdapter = null;

		// 关闭数据库辅助对象
		this.m_Helper.close();

		// 清除对象
		this.m_Helper = null;
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu)
	{
		try
		{
			// 获得菜单对象
			getMenuInflater().inflate(R.menu.activity_component, menu);

			// 返回成功
			return true;
		}
		catch (Exception ex)
		{
			// 记录日志
			Log.e(LOG_TAG, "加载菜单的过程中发生错误。\r\n" + ex.toString());

			// 返回失败
			return false;
		}
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		// 根据选中的菜单项目进行处理
		switch (item.getItemId())
		{
		case R.id.menu_setting:
			// 导航到设定页面
			Utility.startActivity(ComponentActivity.this, SettingActivity.class, null);
			// 终止
			break;
		case R.id.menu_search:

			// 创建参数
			Bundle data = new Bundle();

			// 不使用关键字检索
			this.m_Condition.setUseKeyword(false);

			// 设置检索条件
			data.putSerializable(ComponentSearchActivity.KEY_CONDITION, this.m_Condition);

			// 导航到检索页面
			Utility.startActivityForResult(ComponentActivity.this, ComponentSearchActivity.class, data, CODE_SEARCH);
			// 终止
			break;
		case R.id.menu_sync:
			// 执行数据同步
			ComponentActivity.this.doSync();
			// 终止
			break;
		}

		// 返回成功
		return true;
	}

	/**
	 * 获得数据库操作辅助对象。
	 */
	public DatabaseHelper getDatabaseHelper()
	{
		// 返回数据库操作辅助对象。
		return this.m_Helper;
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data)
	{
		// 判断是否为设定活动返回
		if (requestCode == CODE_SETTING)
		{
			// 判断是否设定成功
			if (resultCode == Activity.RESULT_OK)
			{
				// 执行同步
				this.doSync();
			}
		}
		// 判断是否为检索活动返回
		if (requestCode == CODE_SEARCH)
		{
			// 判断是否设定成功
			if (resultCode == Activity.RESULT_OK)
			{
				// 获得检索条件
				ComponentQueryCondition condition = (ComponentQueryCondition) data.getSerializableExtra(ComponentSearchActivity.KEY_CONDITION);

				// 判断是否有检索条件
				if (null == condition)
				{
					// 如果没有检索条件，则直接返回
					return;
				}

				// 保存检索条件
				this.m_Condition = condition;

				// 执行查询
				ComponentActivity.this.m_ListAdapter.doQuery(ComponentActivity.this.m_Condition);
			}
		}
	}

	/**
	 * 执行数据同步。
	 */
	private void doSync()
	{
		// 判断是否登录
		if (Utility.IsNullOrEmpty(LoginActivity.SESSION_ID))
		{
			// 提示信息
			Utility.notifyLogin(ComponentActivity.this);

			// 返回
			return;
		}
		// 判断是否设定了服务器地址
		else if (!Utility.hasServiceAddress(this))
		{
			// 提示消息
			Utility.notifySetServiceAddress(this);
		}
		else
		{
			// 创建同步任务
			ComponentActivity.SyncTask task = new ComponentActivity.SyncTask(this, this.getDatabaseHelper());

			// 启用同步任务
			task.execute();
		}
	}

	/**
	 * 保存检索条件。
	 */
	private void saveQueryCondition()
	{
		// 获得共享存储器
		SharedPreferences settings = getSharedPreferences(getString(R.string.app_name), 0);

		// 获得编辑器
		Editor editor = settings.edit();

		// 保存检索条件
		editor.putBoolean("UseCode", this.m_Condition.getUseCode());
		editor.putBoolean("UseName", this.m_Condition.getUseName());
		editor.putBoolean("UseKeyword", this.m_Condition.getUseKeyword());
		editor.putBoolean("UseManufacturer", this.m_Condition.getUseManufacturer());
		editor.putString("Code", this.m_Condition.getCode());
		editor.putString("Name", this.m_Condition.getName());
		editor.putString("Keyword", this.m_Condition.getKeyword());
		editor.putString("Manufacturer", this.m_Condition.getManufacturer());

		// 保存数据
		editor.commit();
	}

	/**
	 * 加载检索条件。
	 */
	private void loadQueryCondition()
	{
		// 获得共享存储器
		SharedPreferences settings = getSharedPreferences(getString(R.string.app_name), 0);

		// 创建条件对象
		this.m_Condition = new ComponentQueryCondition();

		// 读取配置
		this.m_Condition.setUseCode(settings.getBoolean("UseCode", false));
		this.m_Condition.setCode(settings.getString("Code", ""));
		this.m_Condition.setUseName(settings.getBoolean("UseName", false));
		this.m_Condition.setName(settings.getString("Name", ""));
		this.m_Condition.setUseKeyword(settings.getBoolean("UseKeyword", false));
		this.m_Condition.setKeyword(settings.getString("Keyword", ""));
		this.m_Condition.setUseManufacturer(settings.getBoolean("UseManufacturer", false));
		this.m_Condition.setManufacturer(settings.getString("Manufacturer", ""));
	}

	/**
	 * 元器件信息列表视图适配器。
	 */
	private class ComponentListAdapter extends BaseAdapter
	{
		/**
		 * 日志标记。
		 */
		private final static String LOG_TAG = "ComponentListAdapter";

		/**
		 * 用于记录数据的总数。
		 */
		private int m_Count;

		/**
		 * 数据库游标。
		 */
		private Cursor m_Cursor;

		/**
		 * 数据库对象。
		 */
		private SQLiteDatabase m_Database;

		/**
		 * 默认缩略图。
		 */
		private final Drawable m_DefaultThumb;

		/**
		 * 布局对象。
		 */
		private final LayoutInflater m_Inflater;

		/**
		 * 构造函数。
		 */
		public ComponentListAdapter()
		{
			// 获得布局对象
			this.m_Inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);

			// 获得默认的缩略图
			this.m_DefaultThumb = getResources().getDrawable(R.drawable.default_thumb);
		}

		/**
		 * 获得记录的总数。
		 */
		public int getCount()
		{
			// 返回记录总数
			return this.m_Count;
		}

		/**
		 * 获得指定位置的数据对象。
		 */
		public Object getItem(int position)
		{
			// 判断是否设置了游标
			if (null == this.m_Cursor)
			{
				// 返回空引用
				return null;
			}
			else
			{
				// 移动到指定数据行
				this.m_Cursor.moveToPosition(position);

				// 获得编号
				return this.m_Cursor.getString(0);
			}
		}

		/**
		 * 获得指定位置的数据对象的编号。
		 */
		public long getItemId(int position)
		{
			// 默认返回位置
			return position;
		}

		/**
		 * 获得指定位置元素的显示视图。
		 */
		public View getView(int position, View convertView, ViewGroup parent)
		{
			// 判断视图是否创建
			if (null == convertView)
			{
				// 创建项目视图
				convertView = this.m_Inflater.inflate(R.layout.listitem_component, null);
			}

			// 判断游标是否有效
			if (null != this.m_Cursor)
			{
				// 移动到当前数据行
				this.m_Cursor.moveToPosition(position);

				// 获得编号控件
				TextView txtCode = (TextView) convertView.findViewById(R.id.txtCode);

				// 设置编号
				txtCode.setText(this.m_Cursor.getString(1));

				// 获得名称控件
				TextView txtName = (TextView) convertView.findViewById(R.id.txtName);

				// 设置名称
				txtName.setText(this.m_Cursor.getString(2));

				// 获得封装方式控件
				TextView txtPackage = (TextView) convertView.findViewById(R.id.txtPackage);

				// 设置封装方式
				txtPackage.setText(this.m_Cursor.getString(3));

				// 获得生产厂家控件
				TextView txtManufacturer = (TextView) convertView.findViewById(R.id.txtManufacturer);

				// 设置生产厂家
				txtManufacturer.setText(this.m_Cursor.getString(4));

				// 获得缩略图控件
				ImageView imgThumb = (ImageView) convertView.findViewById(R.id.imgThumb);

				// 获得缩略图数据
				byte[] data = this.m_Cursor.getBlob(5);

				// 判断是否有数据
				if (null != data && data.length > 0)
				{
					try
					{
						// 生成缩略图
						Bitmap thumb = BitmapFactory.decodeByteArray(data, 0, data.length);

						// 设置缩略图
						imgThumb.setImageBitmap(thumb);
					}
					catch (Exception ex)
					{
						// 记录日志
						Log.e(LOG_TAG, ex.toString());

						// 设置为默认缩略图
						imgThumb.setImageDrawable(this.m_DefaultThumb);
					}
				}
				else
				{
					// 设置为默认缩略图
					imgThumb.setImageDrawable(this.m_DefaultThumb);
				}
			}

			// 返回视图
			return convertView;
		}

		/**
		 * 查询数据。
		 * 
		 * @param condition
		 *            查询条件。
		 */
		public void doQuery(ComponentQueryCondition condition)
		{
			// 关闭
			this.close();

			// 创建同步任务
			QueryTask task = new QueryTask();

			// 启用同步任务
			task.execute(condition);
		}

		/**
		 * 关闭适配器。
		 */
		public void close()
		{
			// 判断当前游标是否存在
			if (this.m_Cursor != null)
			{
				// 关闭游标
				this.m_Cursor.close();

				// 清除游标
				this.m_Cursor = null;
			}

			// 判断当前数据库是否存在
			if (this.m_Database != null)
			{
				// 关闭游标
				this.m_Database.close();

				// 清除游标
				this.m_Database = null;
			}
		}

		/**
		 * 更新数据集合。
		 * 
		 * @param cursor
		 *            数据库对象。
		 * @param cursor
		 *            数据游标。
		 * @param count
		 *            数据总数。
		 */
		public void updateDataSet(SQLiteDatabase database, Cursor cursor, int count)
		{
			// 判断当前游标是否存在
			if (this.m_Cursor != null)
			{
				// 关闭游标
				this.m_Cursor.close();

				// 清除游标
				this.m_Cursor = null;
			}

			// 判断当前数据库是否存在
			if (this.m_Database != null)
			{
				// 关闭游标
				this.m_Database.close();

				// 清除游标
				this.m_Database = null;
			}

			// 保存数据
			this.m_Database = database;
			this.m_Cursor = cursor;
			this.m_Count = count;

			// 通知数据集发生变化
			this.notifyDataSetChanged();
		}

		/**
		 * 数据检索任务。
		 * 
		 * @author zanezeng
		 */
		private class QueryTask extends AsyncTask<ComponentQueryCondition, String, Integer>
		{
			/**
			 * 进度对话框。
			 */
			private ProgressDialog m_ProgressDialog;

			/**
			 * 查询的过程中发生的错误。
			 */
			private Exception m_QueryException;

			/**
			 * 游标对象。
			 */
			private Cursor m_Cursor;

			/**
			 * 数据库对象。
			 */
			private SQLiteDatabase m_Database;

			/**
			 * 日志标记。
			 */
			private final static String LOG_TAG = "QueryTask";

			@Override
			protected void onPreExecute()
			{
				// 创建进度对话框
				this.m_ProgressDialog = new ProgressDialog(ComponentActivity.this);
				// 设置进度条样式
				this.m_ProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
				// 设置标题
				this.m_ProgressDialog.setTitle(R.string.title_search_component);
				// 设置提示信息
				this.m_ProgressDialog.setMessage(ComponentActivity.this.getString(R.string.message_search));
				// 设置允许取消
				this.m_ProgressDialog.setCancelable(true);
				// 挂接后退按钮点击事件
				this.m_ProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener()
				{
					// 处理取消按钮点击事件
					public void onCancel(DialogInterface dialog)
					{
						// 取消任务
						QueryTask.this.cancel(true);
					}
				});
				// 设置按钮标题
				this.m_ProgressDialog.setButton(ComponentActivity.this.getString(R.string.button_cancel), new DialogInterface.OnClickListener()
				{
					public void onClick(DialogInterface dialog, int which)
					{
						// 取消任务
						QueryTask.this.cancel(true);
					}
				});

				// 设置图标
				this.m_ProgressDialog.setIcon(R.drawable.icon_search);
				// 显示对话框
				this.m_ProgressDialog.show();
			}

			@Override
			protected Integer doInBackground(ComponentQueryCondition... params)
			{
				// 进度通知
				this.publishProgress("开始查询数据");

				// 获得查询条件
				ComponentQueryCondition condition = params[0];

				// 获得总数查询字符串
				String queryCount = ComponentActivity.this.getString(R.string.sql_query_component_count);

				// 获得查询字符串
				String query = ComponentActivity.this.getString(R.string.sql_query_component);

				// 用于保存过滤条件
				String filter = "";

				// 判断是否使用关键字检索
				if (condition.getUseKeyword())
				{
					// 获得过滤条件
					filter = String.format("WHERE Code LIKE '%%%1$s%%' OR Name LIKE '%%%1$s%%' OR Manufacturer LIKE '%%%1$s%%' ", condition.getKeyword());
				}
				else
				{
					// 获得编号
					String code = condition.getCode();

					// 判断是否设置了编号
					if (condition.getUseCode() && !Utility.IsNullOrEmpty(code))
					{
						// 组织过滤条件
						filter = String.format("Code LIKE '%%%1$s%%'", code);
					}

					// 获得名称
					String name = condition.getName();

					// 判断是否设置了名称
					if (condition.getUseName() && !Utility.IsNullOrEmpty(name))
					{
						// 判断是否有条件
						if (!Utility.IsNullOrEmpty(filter))
						{
							// 组织过滤条件
							filter = String.format("%1$s OR Name LIKE '%%%2$s%%'", filter, name);
						}
						else
						{
							// 组织过滤条件
							filter = String.format("Name LIKE '%%%1$s%%'", name);
						}
					}

					// 获得生产厂家
					String manufacturer = condition.getManufacturer();

					// 判断是否设置了名称
					if (condition.getUseManufacturer() && !Utility.IsNullOrEmpty(manufacturer))
					{
						// 判断是否有条件
						if (!Utility.IsNullOrEmpty(filter))
						{
							// 组织过滤条件
							filter = String.format("%1$s OR Manufacturer LIKE '%%%2$s%%'", filter, manufacturer);
						}
						else
						{
							// 组织过滤条件
							filter = String.format("Manufacturer LIKE '%%%1$s%%'", manufacturer);
						}
					}

					// 判断是否指定了过滤条件
					if (!Utility.IsNullOrEmpty(filter))
					{
						// 添加条件谓词
						filter = "WHERE " + filter;
					}
				}

				// 设置过滤条件
				query = String.format(query, filter);

				// 设置过滤条件
				queryCount = String.format(queryCount, filter);

				// 清除游标
				this.m_Cursor = null;

				// 用于保存总数
				int count = 0;

				try
				{
					// 获得数据库对象
					this.m_Database = ComponentActivity.this.getDatabaseHelper().getReadableDatabase();

					// 查询总记录数
					count = Utility.querySingleInteger(this.m_Database, queryCount);

					// 进度通知
					this.publishProgress(String.format("检索到%1$d条数据", count));

					// 判断是否有数据
					if (count > 0)
					{
						// 查询数据
						this.m_Cursor = this.m_Database.rawQuery(query, null);
					}
				}
				catch (Exception ex)
				{
					// 保存异常对象
					this.m_QueryException = ex;

					// 设置记录数为-1，表示查询出错
					count = -1;

					// 记录日志
					Log.e(QueryTask.LOG_TAG, ex.toString());

					// 判断游标是否已经创建
					if (null != this.m_Cursor)
					{
						// 关闭游标
						this.m_Cursor.close();

						// 清除游标
						this.m_Cursor = null;
					}

					// 判断数据库是否已经创建
					if (null != this.m_Database)
					{
						// 关闭游标
						this.m_Database.close();

						// 清除游标
						this.m_Database = null;
					}
				}

				// 返回总数
				return count;

			}

			@Override
			protected void onProgressUpdate(String... values)
			{
				// 判断进度窗体是否已经创建
				if (null != this.m_ProgressDialog)
				{
					this.m_ProgressDialog.setMessage(values[0]);
				}
			}

			/**
			 * 同步任务后置处理器。
			 */
			@Override
			protected void onPostExecute(Integer result)
			{
				// 更新数据集
				ComponentListAdapter.this.updateDataSet(this.m_Database, this.m_Cursor, result);

				// 清除游标
				this.m_Cursor = null;
				// 清除数据库
				this.m_Database = null;

				// 进度通知
				this.publishProgress("结束查询数据");

				// 判断是否完成
				if (result < 0 && null != this.m_QueryException)
				{
					// 提示完成
					Toast.makeText(ComponentActivity.this, "数据查询失败，数据查询的过程中发生错误\r\n" + this.m_QueryException.getMessage(), Toast.LENGTH_SHORT).show();
				}

				// 获得元器件列表视图
				ListView lstComponent = (ListView) ComponentActivity.this.findViewById(R.id.lstComponent);

				// 判断是否有数据
				if (result > 0)
				{
					// 选中列表
					lstComponent.setSelected(true);
					// 选中第一行
					lstComponent.setSelection(0);
				}

				// 释放对话框对象
				if (null != this.m_ProgressDialog)
				{
					this.m_ProgressDialog.dismiss();
				}
			}
		}
	}

	/**
	 * 同步任务对象。
	 */
	public static class SyncTask extends AsyncTask<String, String, Integer>
	{
		/**
		 * 进度对话框。
		 */
		private ProgressDialog m_ProgressDialog;

		/**
		 * 同步的过程中发生的错误。
		 */
		private Exception m_SyncException;

		/**
		 * 数据读取缓存长度。
		 */
		private final static int BUFFER_LENGTH = 1024;

		/**
		 * HTTP请求成功编码。
		 */
		private final static int HTTP_OK = 200;

		/**
		 * 连接超时。
		 */
		private final static int CONNECTION_TIMEOUT = 10000;

		/**
		 * 数据接收超时。
		 */
		private final static int SOCKET_TIMEOUT = 30000;

		/**
		 * 日志标记。
		 */
		private final static String LOG_TAG = "SyncTask";

		/**
		 * 上下文对象。
		 */
		private final Activity m_Context;

		/**
		 * 数据库操作辅助对象。
		 */
		private final DatabaseHelper m_Helper;

		/**
		 * 是否自行管理辅助对象。
		 */
		private final boolean m_IsOwnHelper;

		/**
		 * @param context
		 *            上下文对象。
		 */
		public SyncTask(Activity context, DatabaseHelper helper)
		{
			// 保存上下文
			this.m_Context = context;

			// 判断是否指定了辅助类
			if (null == helper)
			{
				// 创建辅助对象
				this.m_Helper = new DatabaseHelper(context);

				// 设置自行管理
				this.m_IsOwnHelper = true;
			}
			else
			{
				// 保存数据库操作辅助对象
				this.m_Helper = helper;

				// 设置非自行管理
				this.m_IsOwnHelper = false;
			}
		}

		@Override
		protected void onPreExecute()
		{
			// 创建进度对话框
			this.m_ProgressDialog = new ProgressDialog(this.m_Context);
			// 设置进度条样式
			this.m_ProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
			// 设置标题
			this.m_ProgressDialog.setTitle(R.string.title_sync_component);
			// 设置提示信息
			this.m_ProgressDialog.setMessage(this.m_Context.getString(R.string.message_sync));
			// 设置允许取消
			this.m_ProgressDialog.setCancelable(true);
			// 挂接后退按钮点击事件
			this.m_ProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener()
			{
				// 处理取消按钮点击事件
				public void onCancel(DialogInterface dialog)
				{
					// 取消任务
					SyncTask.this.cancel(true);
				}
			});
			// 设置按钮标题
			this.m_ProgressDialog.setButton(this.m_Context.getString(R.string.button_cancel), new DialogInterface.OnClickListener()
			{
				public void onClick(DialogInterface dialog, int which)
				{
					// 取消任务
					SyncTask.this.cancel(true);
				}
			});

			// 设置图标
			this.m_ProgressDialog.setIcon(R.drawable.icon_sync);
			// 显示对话框
			this.m_ProgressDialog.show();
		}

		@Override
		protected Integer doInBackground(String... params)
		{
			// 用于保存数据库连接
			SQLiteDatabase database = null;

			try
			{
				// 用于记录同步数据的总数
				int totalRecords = 0;

				// 创建请求客户端
				DefaultHttpClient client = new DefaultHttpClient();

				// 进度通知
				this.publishProgress("开始查询元器件数据的版本信息");

				// 获得可写数据库对象
				database = this.m_Helper.getWritableDatabase();

				// 获得最后同步的数据版本号
				String latestVersion = this.RetrieveLatestVersion(database);

				// 进度通知
				this.publishProgress("完成查询元器件数据的版本信息");

				// 进度通知
				this.publishProgress("开始同步元器件数据");

				// 循环同步数据
				while (true)
				{
					// 查询数据
					JSONArray data = this.RetrieveData(client, latestVersion);

					// 用于保存记录信息
					ContentValues record = new ContentValues();

					// 循环插入到数据库
					for (int index = 0; index < data.length(); index++)
					{
						// 获得单个元器件数据
						JSONObject source = data.getJSONObject(index);

						// 组装记录信息
						this.AssemContentValues(source, record);

						// 删除重复记录
						database.delete("Component", "ID=?", new String[] { record.getAsString("ID") });

						// 插入记录
						database.insert("Component", null, record);

						// 设置最后同步的版本信息
						latestVersion = record.getAsString("Version");

						// 记录已经同步的记录数据
						totalRecords += 1;

						// 进度通知
						this.publishProgress(String.format("%1$d条元器件数据被同步", totalRecords));
					}

					// 判断是否需要继续同步
					if (data.length() < 100)
					{
						// 判断是否同步了数据
						if (totalRecords == 0)
						{
							// 进度通知
							this.publishProgress("没有发现需要同步的元器件数据");
						}

						// 进度通知
						this.publishProgress("结束同步元器件数据");

						// 退出同步
						break;
					}
				}

				// 返回同步成功
				return totalRecords;
			}
			catch (Exception ex)
			{
				// 记录日志
				Log.e(SyncTask.LOG_TAG, ex.toString());

				// 记录同步过程中发生的异常
				this.m_SyncException = ex;

				// 返回同步失败
				return -1;
			}
			finally
			{
				// 关闭数据库连接
				if (null != database)
				{
					database.close();
				}

				// 判断是否自行管理辅助类
				if (this.m_IsOwnHelper)
				{
					// 关闭辅助对象
					this.m_Helper.close();
				}
			}
		}

		@Override
		protected void onProgressUpdate(String... values)
		{
			// 判断进度窗体是否已经创建
			if (null != this.m_ProgressDialog)
			{
				this.m_ProgressDialog.setMessage(values[0]);
			}
		}

		/**
		 * 同步任务后置处理器。
		 */
		@Override
		protected void onPostExecute(Integer result)
		{
			// 释放对话框对象
			if (null != this.m_ProgressDialog)
			{
				this.m_ProgressDialog.dismiss();
			}

			// 判断是否同步成功
			if (result == 0)
			{
				// 提示完成
				Toast.makeText(this.m_Context, "同步完成，没有发现需要同步的元器件数据", Toast.LENGTH_SHORT).show();
			}
			else if (result > 0)
			{
				// 提示完成
				Toast.makeText(this.m_Context, String.format("同步完成，%1$d条元器件数据被同步", result), Toast.LENGTH_SHORT).show();
			}
			else if (null != this.m_SyncException)
			{
				// 创建对话框
				AlertDialog.Builder dialog = new AlertDialog.Builder(this.m_Context);

				// 设置标题
				dialog.setTitle(R.string.title_application_name);
				// 设置消息
				dialog.setMessage("同步失败，数据同步的过程中发生错误：\r\n" + this.m_SyncException.toString());
				// 设置不允许取消
				dialog.setCancelable(false);
				// 设置图标编号
				dialog.setIcon(R.drawable.icon_error);

				// 添加取消按钮
				dialog.setPositiveButton(R.string.button_ok, new OnClickListener()
				{
					// 处理点击事件
					public void onClick(DialogInterface dialog, int which)
					{
						// 关闭对话框
						dialog.dismiss();
					}
				});

				// 显示对话框
				dialog.show();
			}
		}

		/**
		 * 获得同步的最晚数据版本。
		 */
		private String RetrieveLatestVersion(SQLiteDatabase database)
		{
			// 获得查询语句
			String query = this.m_Context.getResources().getString(R.string.sql_query_component_max_version);

			// 用于保存版本号
			Long latestVersion = Utility.querySingleLong(database, query);

			// 判断是否有数据
			if (null == latestVersion)
			{
				// 默认为0
				latestVersion = 0L;
			}

			// 返回版本号
			return Long.toString(latestVersion);
		}

		/**
		 * 从服务端获得元器件数据。
		 */
		private JSONArray RetrieveData(DefaultHttpClient client, String version) throws Exception
		{
			// 获得共享存储器
			SharedPreferences settings = this.m_Context.getSharedPreferences(this.m_Context.getString(R.string.app_name), 0);

			// 读取服务器地址
			String serverAddress = settings.getString(SettingActivity.KEY_ADDRESS, null);

			// 判断是否以/结尾
			if (serverAddress.endsWith("/"))
			{
				serverAddress = String.format("%1$sServices/MobileService.svc/GetComponentInfo/", serverAddress);
			}
			else
			{
				serverAddress = String.format("%1$s/Services/MobileService.svc/GetComponentInfo/", serverAddress);
			}

			// 获得服务端地址
			String url = serverAddress + version;

			// 创建HTTP请求对象
			HttpGet request = new HttpGet(url);

			// 获得请求参数
			HttpParams params = request.getParams();

			// 设置连接超时
			HttpConnectionParams.setConnectionTimeout(params, SyncTask.CONNECTION_TIMEOUT);
			// 设置接收超时
			HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);

			// 执行请求
			HttpResponse response = client.execute(request);

			// 读取反馈内容
			String responseText = RetrieveInputStream(response.getEntity());

			// 判断是否请求成功
			if (SyncTask.HTTP_OK != response.getStatusLine().getStatusCode())
			{
				// 记录日志
				Log.e(SyncTask.LOG_TAG, responseText);

				// 抛出异常
				throw new Exception(responseText);
			}

			// 返回数据
			return new JSONArray(responseText);
		}

		/**
		 * 从给定的HTTP实体中获得反馈内容。
		 */
		private String RetrieveInputStream(HttpEntity entity) throws Exception
		{
			// 获得内容长度
			int length = (int) entity.getContentLength();

			// 判断长度是否小于0
			if (length < 0)
			{
				// 如果小于0，则默认为10K
				length = 10 * SyncTask.BUFFER_LENGTH;
			}

			// 用于保存返回字符串内容
			StringBuffer result = new StringBuffer(length);

			// 创建输入流读取器
			InputStreamReader reader = new InputStreamReader(entity.getContent(), HTTP.UTF_8);

			// 用于保存缓存数据
			char buffer[] = new char[SyncTask.BUFFER_LENGTH];

			// 用于记录读取的数据长度
			int count = 0;

			// 循环读取数据
			do
			{
				// 读取数据
				count = reader.read(buffer, 0, SyncTask.BUFFER_LENGTH);

				// 判断是否读取了数据
				if (count > 0)
				{
					// 添加数据
					result.append(buffer, 0, count);
				}
			}
			while (count > 0);

			// 返回结果
			return result.toString();
		}

		/**
		 * 根据给定的JSON对象组装元器件信息记录对象。
		 */
		private void AssemContentValues(JSONObject source, ContentValues record) throws JSONException
		{
			// 清除内容
			record.clear();

			// 设置版本
			if (!source.isNull("Version"))
			{
				record.put("Version", source.getString("Version"));
			}

			// 设置编号
			if (!source.isNull("ID"))
			{
				record.put("ID", source.getString("ID"));
			}

			// 设置编号
			if (!source.isNull("Code"))
			{
				record.put("Code", source.getString("Code"));
			}

			// 设置名称
			if (!source.isNull("Name"))
			{
				record.put("Name", source.getString("Name"));
			}

			// 设置生产厂商
			if (!source.isNull("Manufacturer"))
			{
				record.put("Manufacturer", source.getString("Manufacturer"));
			}

			// 设置封装方式
			if (!source.isNull("Package"))
			{
				record.put("Package", source.getString("Package"));
			}

			// 设置质量等级
			if (!source.isNull("Grade"))
			{
				record.put("Grade", source.getString("Grade"));
			}

			// 设置分类
			if (!source.isNull("Category"))
			{
				record.put("Category", source.getString("Category"));
			}

			// 设置工作温度
			if (!source.isNull("WorkingTemperature"))
			{
				record.put("WorkingTemperature", source.getString("WorkingTemperature"));
			}

			// 设置存储温度
			if (!source.isNull("StorageTemperature"))
			{
				record.put("StorageTemperature", source.getString("StorageTemperature"));
			}

			// 设置备注
			if (!source.isNull("Memo"))
			{
				record.put("Memo", source.getString("Memo"));
			}

			// 设置图片
			if (!source.isNull("Picture1"))
			{
				record.put("Picture1", this.ExtractPicture(source.getString("Picture1")));
			}

			// 设置图片
			if (!source.isNull("Picture2"))
			{
				record.put("Picture2", this.ExtractPicture(source.getString("Picture2")));
			}

			// 设置图片
			if (!source.isNull("Picture3"))
			{
				record.put("Picture3", this.ExtractPicture(source.getString("Picture3")));
			}

			// 设置图片
			if (!source.isNull("Picture4"))
			{
				record.put("Picture4", this.ExtractPicture(source.getString("Picture4")));
			}

			// 设置能否PIND
			if (!source.isNull("PIND"))
			{
				record.put("PIND", source.getBoolean("PIND"));
			}

			// 设置能否检漏
			if (!source.isNull("LeakHunting"))
			{
				record.put("LeakHunting", source.getBoolean("LeakHunting"));
			}

			// 设置能否测试
			if (!source.isNull("IsTestable"))
			{
				record.put("IsTestable", source.getBoolean("IsTestable"));
			}
		}

		/**
		 * 从给定的字符串中解析图片资源。
		 */
		private byte[] ExtractPicture(String data)
		{
			// 解码图片内容
			return Base64.decode(data, Base64.DEFAULT);
		}
	}
}
